/*
 * SERVLET
 */
package br.com.jkar.controle;

import br.com.jkar.bean.Servico;
import br.com.jkar.dao.ServicoDAO;
import br.com.jkar.dao.ServicoDAOImpl;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 *
 * @author Kamila Berto <kah.berto@gmail.com>
 */
@WebServlet(name = "ServicoServlet", urlPatterns = {"/serv.do"})
public class ServicoServlet extends HttpServlet {

    //    private HttpServletRequest request;
//    private HttpServletResponse response;
    //Não precisa declarar request e response aqui pois já estão sendo passados como parâmetros de doPost() e só são usados lá
//    private RequestDispatcher rd;
//    private Servico servico;
//    private ServicoDAO servicoDAO;
    //Serão declarados localmente, dentro de processRequest()
    /**
     * Neste servlet, doGet() e doPost() apenas encaminharão o request e o
     * response para o processRequest(), que processará os dados de fato É
     * preciso um método de cada, pois mesmo que todos os formulários sejam
     * programados para enviar por POST, o servlet pode receber informações por
     * outros meios, como os links enviados por "href".
     *
     * @param request
     * @param response
     * @throws ServletException
     * @throws IOException
     */
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        processRequest(request, response);
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        processRequest(request, response);
    }

    /**
     * Receber a ação solicitada no formulário e encaminhar para o método
     * correspondente.
     *
     * @param request
     * @param response
     * @throws ServletException
     * @throws IOException
     */
    protected void processRequest(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {

        RequestDispatcher rd;

        //Recuperar do JSP o comando solicitado no menu, para saber o que fazer
        String cmd = request.getParameter("cmd");

        ServicoDAO servicoDAO = new ServicoDAOImpl();

        try {
            switch (cmd) {
                case "listar":
                    listarAtivos(request, response, servicoDAO, null);
                    break;
                case "pesquisarNome":
                    pesquisarNome(request, response, servicoDAO);
                    break;
                case "salvar":
                    salvar(request, response, servicoDAO);
                    break;
                case "formAlt":
                    gerarFormAlt(request, response, servicoDAO);
                    break;
                case "alterar":
                    alterar(request, response, servicoDAO);
                    break;
                case "excluir":
                    excluir(request, response, servicoDAO);
                    listarAtivos(request, response, servicoDAO, "?msgDel=1");
                    break;
                default:
                    rd = request.getRequestDispatcher("index.jsp?msgErro=1");
                    rd.forward(request, response);
            }
        } catch (Exception ex) {
            rd = request.getRequestDispatcher("index.jsp?msgErro=2");
            rd.forward(request, response);
        }

    }//fim do processRequest();

    /**
     * # Recuperar dados do formulário # Recupera do JSP os dados digitados em
     * cada campo dos formulários, retornando um objeto Servico que será
     * utilizado pelos outros métodos
     *
     * @param request
     * @param status
     * @return
     */
    private Servico prepararServico(HttpServletRequest request, String status) {
        Servico servicoForm = new Servico();
        servicoForm.setNome(request.getParameter("nome"));
        servicoForm.setDescricao(request.getParameter("descricao"));
        servicoForm.setValor(request.getParameter("valor"));
        servicoForm.setStatus(status);
        if (request.getParameter("id") != null && !request.getParameter("id").equals("")) {
            servicoForm.setId(Integer.parseInt(request.getParameter("id")));
        }
        return servicoForm;
    }//fim de prepararServico()

    /**
     * # Salvar os dados no BD # Executa prepararServico(), que retornará um
     * objeto Servico pronto, e depois executa o metodo salvar() do DAO,
     * passando esse objeto como parâmetro. Como é o momento de criação de um
     * novo Serviço pelo usuário, o sistema automaticamente configura o Status
     * como Ativo. Gravados os dados no BD, o objeto Servico retornado será
     * enviado para uma página em que será apresentada a mensagem de sucesso da
     * operação, bem como as informações salvas.
     *
     * @param request
     * @param response
     * @param servicoDAO
     */
    private void salvar(HttpServletRequest request, HttpServletResponse response,
            ServicoDAO servicoDAO) {
        try {
            Servico servicoForm = prepararServico(request, "Ativo");
            //Esse é o objeto completo, com o ID, que volta do salvar() da Impl 
            Servico servico = servicoDAO.salvar(servicoForm);
            request.setAttribute("serv", servico);
            request.getRequestDispatcher("servcadok.jsp").forward(request, response);
        } catch (Exception ex) {
            Logger.getLogger(ServicoServlet.class.getName()).log(Level.SEVERE, null, ex);
        }
    }//fim de salvar()

    /**
     * # Gerar formulário de alteração dos dados # Quando for solicitada uma
     * alteração dos dados, através da lista exibida, este método irá receber o
     * ID do item selecionado e executar o método pesquisarId(), do DAO,
     * passando esse número como parâmetro. Como retorno, recebe um objeto
     * Servico completo, que será enviado de volta ao JSP por meio da variável
     * "serv", criada no servlet mesmo.
     *
     * @param request
     * @param response
     * @param servicoDAO
     */
    private void gerarFormAlt(HttpServletRequest request, HttpServletResponse response,
            ServicoDAO servicoDAO) {
        try {
            Integer id = Integer.parseInt(request.getParameter("id"));
            Servico servico = servicoDAO.pesquisarId(id);
            request.setAttribute("serv", servico);
            request.getRequestDispatcher("servalt.jsp").forward(request, response);
        } catch (Exception ex) {
            Logger.getLogger(ServicoServlet.class.getName()).log(Level.SEVERE, null, ex);
        }
    }//fim de gerarForm()

    /**
     * # Salvar alterações realizadas pelo usuário # Capta o valor de Status
     * para repassar ao método prepararServico(), executado em seguida e
     * retornando um objeto Servico completo. Segue os mesmos passos de
     * "cadastrar", porém o formulário de alteração já será carregado com os
     * dados salvos no BD. Presumindo que o usuário, querendo excluir (inativar)
     * um serviço, irá clicar em "excluir" (botão abaixo de "alterar") e não em
     * "alterar", não há aqui uma opção de Ativar/Desativar acessada diretamente
     * pelo usuário. De forma semelhante ao salvar(), após gravadas as
     * alterações no BD, o objeto Servico retornado será enviado a uma "página
     * de sucesso", apresentando as informações salvas.
     *
     * @param request
     * @param response
     * @param servicoDAO
     */
    private void alterar(HttpServletRequest request, HttpServletResponse response,
            ServicoDAO servicoDAO) {
        try {
            String status = request.getParameter("status");
            Servico servicoForm = prepararServico(request, status);
            //Serviço já com a alteração salva no BD:
            Servico servico = servicoDAO.alterar(servicoForm);
            request.setAttribute("serv", servico);
            request.getRequestDispatcher("servaltok.jsp").forward(request, response);
        } catch (Exception ex) {
            Logger.getLogger(ServicoServlet.class.getName()).log(Level.SEVERE, null, ex);
        }
    }//fim de alterar

    /**
     * # Realizar a exclusão lógica de um serviço # Recebe o ID selecionado pelo
     * usuário e executa o método excluir(), do DAO, que irá desativar o item,
     * atualizando o status para "Inativo". Dessa forma, o serviço continuará
     * existindo, mas deixará de estar visível ao usuário. Porém, a qualquer
     * momento o usuário poderá visualizar os ítens excluídos e recuperá-los
     * (reativá-los).
     *
     * @param request
     * @param response
     * @param servicoDAO
     */
    private void excluir(HttpServletRequest request, HttpServletResponse response,
            ServicoDAO servicoDAO) {
        try {
            Integer id = Integer.parseInt(request.getParameter("id"));
            servicoDAO.excluir(id);
        } catch (Exception ex) {
            Logger.getLogger(ServicoServlet.class.getName()).log(Level.SEVERE, null, ex);
        }
    }//fim de excluir

    /**
     * # Listar todos os serviços ativos # Cria uma lista do tipo Servico para
     * receber a lista retornada pelo método listarAtivos(), do DAO, que será
     * executado em seguida. Tal lista conterá todos os ítens salvos e com
     * status="Ativo". Caso seja passado como parâmetro uma String contendo
     * mensagem de exclusão (pelo excluir()), tal parâmetro será encaminhado
     * junto ao caminho do JSP, para que, processado, o JSP contenha, além da
     * lista de ítens ativos, uma mensagem de exclusão com sucesso. com sucesso.
     *
     * @param request
     * @param response
     * @param servicoDAO
     * @param msgDel
     */
    private void listarAtivos(HttpServletRequest request, HttpServletResponse response,
            ServicoDAO servicoDAO, String msgDel) {
        try {
            List<Servico> servicos = servicoDAO.listarAtivos();
            request.setAttribute("servicos", servicos);
            if (msgDel != null) {
                request.getRequestDispatcher("servlist.jsp" + msgDel).forward(request, response);
            }
            request.getRequestDispatcher("servlist.jsp").forward(request, response);
        } catch (Exception ex) {
            Logger.getLogger(ServicoServlet.class.getName()).log(Level.SEVERE, null, ex);
        }
    }//fim de listarAtivos()

    /**
     * # Pesquisar um serviço através do campo nome # Recebe uma String com o
     * nome enviado pelo usuário e executa o método pesquisarNome(), do DAO, que
     * irá retornar uma lista de serviços. Tal lista conterá todos os ítens
     * ativos que correspondam à pesquisa e será encaminhada para exibição em
     * tela/browser.
     *
     * @param request
     * @param response
     * @param servicoDAO
     */
    private void pesquisarNome(HttpServletRequest request, HttpServletResponse response,
            ServicoDAO servicoDAO) {
        try {
            String nome = request.getParameter("nomePesq");
            List<Servico> servicosPesq = servicoDAO.pesquisarNome(nome);
            request.setAttribute("servicosPesq", servicosPesq);
            request.getRequestDispatcher("servpesqresult.jsp").forward(request, response);
        } catch (Exception ex) {
            Logger.getLogger(ServicoServlet.class.getName()).log(Level.SEVERE, null, ex);
        }
    }//fim de pesquisarNome

}//fim do servlet

